﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;


//运算符重载

////全局运算符重载
//
//class Date
//{
//public:
//	//全缺省构造函数
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	//拷贝构造函数
//	Date(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//	//析构函数默认生成就好
////private:
//	int _year;
//	int _month;
//	int _day;
//};
//
////全局运算符重载，由于要访问Date类中的成员变量（私有），所以需要将成员变量公有（不推荐）
//bool operator==(const Date& d1, const Date& d2)
//{
//	return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
//}
//
//int main()
//{
//	Date d1(2025, 8, 16);
//	Date d2(2025, 8, 16);
//
//
//	if (operator==(d1, d2))
//	{
//		cout << "同一天" << endl;
//	}
//
//	return 0;
//}


////重载为成员函数
//
//class Date
//{
//public:
//	//全缺省构造函数
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	//拷贝构造函数
//	Date(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//	//将运算符重载函数变为成员函数，解决将成员变量公有的问题
//	bool operator==(const Date& d2)
//	{
//		return (this->_year == d2._year) && (_month == d2._month) && (_day == d2._day);
//	}
//
//	//析构函数默认生成就好
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//
//
//int main()
//{
//	Date d1(2025, 8, 16);
//	Date d2(2025, 8, 16);
//
//	//此时，Operator==为成员函数，默认第一个参数为this指针，则实际上要少传一个参数
//	if (d1.operator==(d2))
//	{
//		cout << "同一天" << endl;
//	}
//
//	//d1==d2 编译器会转化为d1.operator(d2）
//	if (d1 == d2)
//	{
//		cout << "同一天" << endl;
//	}
//	return 0;
//}



//class Date
//{
//public:
//	Date operator+()
//	{
//		//...
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};



//赋值运算符重载

//class Date
//{
//public:
//	//全缺省构造函数
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	//拷贝构造函数
//	Date(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//	//赋值运算符重载
//
//	//引用做参数，同时引用返回来提高效率
//	Date& operator=(const Date& d)
//	{
//		if (this != &d)
//		{
//			_year = d._year;
//			_month = d._month;
//			_day = d._day;
//		}
//		return *this;
//	}
//
//	////赋值运算符函数重载的参数也可以是传值传参，只是传值传参会调用拷贝构造函数，多一次拷贝
//	///*赋值运算符的调用前提是 “左侧对象已经存在”（拷贝构造函数用于初始化新对象，而赋值运算符用于修改已有对象），
// //   参数的拷贝仅发生一次，没有循环依赖*/
//	///*拷贝构造函数的作用是初始化新对象，而传值参数本身又需要用拷贝构造函数来初始化，形成 “初始化新对象→拷贝参数→再初始化新对象” 的循环*/
//	//Date& operator=(Date d)
//	//{
//	//	if (this != &d)
//	//	{
//	//		_year = d._year;
//	//		_month = d._month;
//	//		_day = d._day;
//	//	}
//	//	return *this;
//	//}
//
//	//析构函数默认生成就好
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//
//
//int main()
//{
//	Date d1(2025, 8, 16);
//	Date d2(2025, 8, 15);
//
//	d2 = d2.operator=(d1);//调用赋值运算符重载，两个已经存在的对象d1和d2
//	d2.Print();
//
//	d2 = d1;//调用赋值运算符重载
//	d2.Print();
//
//	//拷贝构造函数
//	//用已存在的对象初始化d3和d4
//	Date d3(d1);
//
//	Date d4 = d1;
//
//	//赋值运算符重载
//	d4 = d3 = d2 = d1;
//
//	return 0;
//}

////Stack类，由于_arr指向资源，所以赋值运算符重载函数必须自己实现
//
//class Stack
//{
//public:
//	Stack(int n = 4)
//	{
//		int* tmp = (int*)malloc(sizeof(int) * n);
//		if (tmp == nullptr)
//		{
//			perror("malloc");
//			exit(1);
//		}
//		_arr = tmp;
//		_top = 0;
//		_capacity = n;
//	}
//
//	//赋值运算符重载
//	Stack& operator=(const Stack& st)
//	{
//		int* _arr = (int*)malloc(sizeof(int) * st._capacity);
//		if (_arr == nullptr)
//		{
//			perror("malloc");
//			exit(1);
//		}
//		memcpy(_arr, st._arr, sizeof(int) * st._top);
//		_top = st._top;
//		_capacity = st._capacity;
//		return *this;
//	}
//
//	//析构函数
//	~Stack()
//	{
//		free(_arr);
//		_arr = nullptr;
//		_top = _capacity = 0;
//	}
//private:
//	int* _arr;
//	int _top;
//	int _capacity;
//};
//
//int main()
//{
//	Stack st1;
//	Stack st2;
//
//	st2 = st1;
//
//	return 0;
//}


//class Date{};
////两个参数都是类类型的
//int operator+(Date d1, Date d2);
////有一个类类型的参数
//int operator+(Date d, int x);
////没有类类型参数（错误示范）
//int operator+(int x, int y);


////错误示范：将<<重载为成员函数
//class Date
//{
//public:
//	ostream& operator<<(ostream& out)
//	{
//		out << date;
//		return out;
//	}
////private:
//	int date;
//};
//int main()
//{
//	Date d;
//	d << cout;//成员函数，默认第一个参数为this指针，因此对象再左边，不符合使用习惯
//	return 0;
//}
//
////正确示范：重载为全局函数
//ostream& operator<<(ostream& out, Date& d)
//{
//	out << d.date;
//	return out;
//}


//取地址运算符重载

//const成员函数

//class Date
//{
//public:
//	Date(int year = 1)
//	{
//		_year = year;
//	}
//
//	void Print()const
//	{
//		cout << _year << endl;
//	}
//private:
//	int _year;
//};
//
//int main()
//{
//	const Date d(2025);
//	d.Print();
//	return 0;
//}

//// 普通取地址运算符重载  
//class Example 
//{
//public:
//    Example* operator&() 
//    { 
//        return this; 
//    }
//};
//
//// const取地址运算符重载  
//class ConstExample 
//{
//public:
//    const ConstExample* operator&() const 
//    { 
//        return this; 
//    }
//};


//const成员函数

class Date
{
public:
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    /*Date* operator&()
    {
        return this;
    }
    const Date* operator&()const
    {
        return this;
    }*/
    /*const int* operator&()const
    {
        return &_year;
    }*/
private:
    int _year; // 年
    int _month; // ⽉
    int _day; // ⽇

};
int main()
{
    Date d(2025,8,19);
    cout << &d << endl;
    //cout << d.operator&() << endl;
    return 0;
}
